WORST_CASE(?,O(n^1))
* Step 1: Ara WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            eqNat#2(0(),0()) -> True()
            eqNat#2(0(),S(x20)) -> False()
            eqNat#2(S(x20),0()) -> False()
            eqNat#2(S(x4),S(x2)) -> eqNat#2(x4,x2)
            eval2#5(x10,x8,x6,x4,Not(x2)) -> lnot#1(eval2#5(x10,x8,x6,x4,x2))
            eval2#5(x12,x10,x8,x6,And(x4,x2)) -> land#2(eval2#5(x12,x10,x8,x6,x4),eval2#5(x12,x10,x8,x6,x2))
            eval2#5(x12,x10,x8,x6,Or(x4,x2)) -> lor#2(eval2#5(x12,x10,x8,x6,x4),eval2#5(x12,x10,x8,x6,x2))
            eval2#5(x22,x20,x14,x10,Var(x6)) -> ite_b#2(eqNat#2(x6,x22),x20,ite#3(eqNat#2(x6,x14),x10))
            ite#3(False(),x1) -> bot[0]#1()
            ite#3(True(),x1) -> x1
            ite_b#2(False(),x20,x24) -> x24
            ite_b#2(True(),x20,x24) -> x20
            land#2(False(),x28) -> False()
            land#2(True(),x28) -> x28
            lnot#1(False()) -> True()
            lnot#1(True()) -> False()
            lor#2(False(),x32) -> x32
            lor#2(True(),x32) -> True()
            main(x3,x2,x1) -> Cons(Triple(True(),True(),eval2#5(x3,True(),x2,True(),x1))
                                  ,Cons(Triple(True(),False(),eval2#5(x3,True(),x2,False(),x1))
                                       ,Cons(Triple(False(),True(),eval2#5(x3,False(),x2,True(),x1))
                                            ,Cons(Triple(False(),False(),eval2#5(x3,False(),x2,False(),x1)),Nil()))))
        - Signature:
            {eqNat#2/2,eval2#5/5,ite#3/2,ite_b#2/3,land#2/2,lnot#1/1,lor#2/2,main/3} / {0/0,And/2,Cons/2,False/0,Nil/0
            ,Not/1,Or/2,S/1,Triple/3,True/0,Var/1,bot[0]#1/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {eqNat#2,eval2#5,ite#3,ite_b#2,land#2,lnot#1,lor#2
            ,main} and constructors {0,And,Cons,False,Nil,Not,Or,S,Triple,True,Var,bot[0]#1}
    + Applied Processor:
        Ara {araHeuristics = NoHeuristics, minDegree = 1, maxDegree = 2, araTimeout = 5, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          0 :: [] -(0)-> "A"(1)
          0 :: [] -(0)-> "A"(0)
          And :: ["A"(7) x "A"(7)] -(7)-> "A"(7)
          Cons :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          Cons :: ["A"(0) x "A"(0)] -(1)-> "A"(1)
          False :: [] -(0)-> "A"(0)
          Nil :: [] -(0)-> "A"(0)
          Not :: ["A"(7)] -(7)-> "A"(7)
          Or :: ["A"(7) x "A"(7)] -(7)-> "A"(7)
          S :: ["A"(0)] -(0)-> "A"(0)
          S :: ["A"(1)] -(1)-> "A"(1)
          Triple :: ["A"(0) x "A"(0) x "A"(0)] -(0)-> "A"(0)
          Triple :: ["A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(1)
          True :: [] -(0)-> "A"(0)
          Var :: ["A"(7)] -(0)-> "A"(7)
          bot[0]#1 :: [] -(0)-> "A"(0)
          eqNat#2 :: ["A"(1) x "A"(0)] -(1)-> "A"(0)
          eval2#5 :: ["A"(0) x "A"(0) x "A"(0) x "A"(0) x "A"(7)] -(5)-> "A"(0)
          ite#3 :: ["A"(0) x "A"(0)] -(1)-> "A"(0)
          ite_b#2 :: ["A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(0)
          land#2 :: ["A"(0) x "A"(0)] -(1)-> "A"(0)
          lnot#1 :: ["A"(0)] -(1)-> "A"(0)
          lor#2 :: ["A"(0) x "A"(0)] -(1)-> "A"(0)
          main :: ["A"(0) x "A"(0) x "A"(28)] -(23)-> "A"(0)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
          "0_A" :: [] -(0)-> "A"(1)
          "And_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
          "Cons_A" :: ["A"(0) x "A"(0)] -(1)-> "A"(1)
          "False_A" :: [] -(0)-> "A"(1)
          "Nil_A" :: [] -(0)-> "A"(1)
          "Not_A" :: ["A"(1)] -(1)-> "A"(1)
          "Or_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
          "S_A" :: ["A"(1)] -(1)-> "A"(1)
          "Triple_A" :: ["A"(0) x "A"(0) x "A"(0)] -(1)-> "A"(1)
          "True_A" :: [] -(0)-> "A"(1)
          "Var_A" :: ["A"(1)] -(0)-> "A"(1)
          "bot[0]#1_A" :: [] -(0)-> "A"(1)
        

WORST_CASE(?,O(n^1))